New XS_SET_TARGET

Stubdomains (and probably other domain disagregation elements too)
need to be able to tinker with another domain.  This adds
XS_SET_TARGET so that XenStore allows domains to have permissions on
files on which the "target" has permissions.  This also adds
xs_set_target, called by the domain builder when the 'target' option
is used in the configuration.

Signed-off-by: Samuel Thibault <samuel.thibault@eu.citrix.com>

diff --git a/tools/python/xen/lowlevel/xs/xs.c b/tools/python/xen/lowlevel/xs/xs.c
index b2c4b090e467693ca16513f74aa839c19149b701..d05365cb167c2145b161f2abd836d6284947e81e 100644 (file)
--- a/tools/python/xen/lowlevel/xs/xs.c
+++ b/tools/python/xen/lowlevel/xs/xs.c
@@ -619,6 +619,36 @@ static PyObject *xspy_introduce_domain(XsHandle *self, PyObject *args)
     return none(result);
 }
 
+#define xspy_set_target_doc "\n"                                       \
+        "Tell xenstore that a domain is targetting another one so it\n" \
+        "should let it tinker with it.\n"                              \
+       " dom    [int]   : domain id\n"                                 \
+       " target [int]   : domain id of the target\n"                   \
+       "\n"                                                            \
+       "Returns None on success.\n"                                    \
+       "Raises xen.lowlevel.xs.Error on error.\n"                      \
+       "\n"
+
+static PyObject *xspy_set_target(XsHandle *self, PyObject *args)
+{
+    uint32_t dom;
+    uint32_t target;
+
+    struct xs_handle *xh = xshandle(self);
+    bool result = 0;
+
+    if (!xh)
+        return NULL;
+    if (!PyArg_ParseTuple(args, "ii", &dom, &target))
+        return NULL;
+
+    Py_BEGIN_ALLOW_THREADS
+    result = xs_set_target(xh, dom, target);
+    Py_END_ALLOW_THREADS
+
+    return none(result);
+}
+
 #define xspy_resume_domain_doc "\n"                                \
        "Tell xenstore to clear its shutdown flag for a domain.\n" \
        "This ensures that a subsequent shutdown will fire the\n"  \
@@ -817,6 +847,7 @@ static PyMethodDef xshandle_methods[] = {
     XSPY_METH(transaction_start, METH_NOARGS),
     XSPY_METH(transaction_end,   METH_VARARGS | METH_KEYWORDS),
     XSPY_METH(introduce_domain,  METH_VARARGS),
+    XSPY_METH(set_target,        METH_VARARGS),
     XSPY_METH(resume_domain,     METH_VARARGS),
     XSPY_METH(release_domain,    METH_VARARGS),
     XSPY_METH(close,             METH_NOARGS),

diff --git a/tools/python/xen/xend/XendDomainInfo.py b/tools/python/xen/xend/XendDomainInfo.py
index 38d276748a0f17220978197df6bdaebb62eb67c0..fc6c324093ee6b7c537d15b224b8cc8218c6c87d 100644 (file)
--- a/tools/python/xen/xend/XendDomainInfo.py
+++ b/tools/python/xen/xend/XendDomainInfo.py
@@ -47,7 +47,7 @@ from xen.xend.XendError import XendError, VmError
 from xen.xend.XendDevices import XendDevices
 from xen.xend.XendTask import XendTask
 from xen.xend.xenstore.xstransact import xstransact, complete
-from xen.xend.xenstore.xsutil import GetDomainPath, IntroduceDomain, ResumeDomain
+from xen.xend.xenstore.xsutil import GetDomainPath, IntroduceDomain, SetTarget, ResumeDomain
 from xen.xend.xenstore.xswatch import xswatch
 from xen.xend.XendConstants import *
 from xen.xend.XendAPIConstants import *
@@ -883,6 +883,9 @@ class XendDomainInfo:
     def storeVm(self, *args):
         return xstransact.Store(self.vmpath, *args)
 
+    def permissionsVm(self, *args):
+        return xstransact.SetPermissions(self.vmpath, *args)
+
 
     def _readVmTxn(self, transaction,  *args):
         paths = map(lambda x: self.vmpath + "/" + x, args)
@@ -904,6 +907,10 @@ class XendDomainInfo:
         paths = map(lambda x: self.vmpath + "/" + x, args)
         return transaction.store(*paths)
 
+    def permissionsVmTxn(self, transaction,  *args):
+        paths = map(lambda x: self.vmpath + "/" + x, args)
+        return transaction.set_permissions(*paths)
+
     #
     # Function to update xenstore /dom/*
     #
@@ -1692,6 +1699,15 @@ class XendDomainInfo:
         except RuntimeError, exn:
             raise XendError(str(exn))
 
+    def _setTarget(self, target):
+        assert self.domid is not None
+
+        try:
+            SetTarget(self.domid, target)
+            self.storeDom('target', target)
+        except RuntimeError, exn:
+            raise XendError(str(exn))
+
 
     def _initDomain(self):
         log.debug('XendDomainInfo.initDomain: %s %s',
@@ -1756,6 +1772,8 @@ class XendDomainInfo:
                 self.native_protocol = channel_details['native_protocol'];
 
             self._introduceDomain()
+            if self.info.target():
+                self._setTarget(self.info.target())
 
             self._createDevices()
 

diff --git a/tools/python/xen/xend/image.py b/tools/python/xen/xend/image.py
index ca79cb8faedfb92671fe5fa8d10130f4900a4e33..793c2b9aa86a01abbc82270749a4dfe0e68ae13b 100644 (file)
--- a/tools/python/xen/xend/image.py
+++ b/tools/python/xen/xend/image.py
@@ -222,6 +222,7 @@ class ImageHandler:
             vncopts = ""
             if passwd:
                 self.vm.storeVm("vncpasswd", passwd)
+                self.vm.permissionsVm("vncpasswd", { 'dom': self.vm.getDomid(), 'read': True } )
                 vncopts = vncopts + ",password"
                 log.debug("Stored a VNC password for vfb access")
             else:
@@ -280,6 +281,9 @@ class ImageHandler:
             env['XAUTHORITY'] = self.xauthority
         if self.vncconsole:
             args = args + ([ "-vncviewer" ])
+        xstransact.Mkdir("/local/domain/0/device-model/%i" % self.vm.getDomid())
+        xstransact.SetPermissions("/local/domain/0/device-model/%i" % self.vm.getDomid(),
+                        { 'dom': self.vm.getDomid(), 'read': True, 'write': True })
         log.info("spawning device models: %s %s", self.device_model, args)
         # keep track of pid and spawned options to kill it later
         self.pid = os.spawnve(os.P_NOWAIT, self.device_model, args, env)
@@ -422,7 +426,9 @@ class HVMImageHandler(ImageHandler):
         self.vm.storeVm(("image/dmargs", " ".join(self.dmargs)),
                         ("image/device-model", self.device_model),
                         ("image/display", self.display))
+        self.vm.permissionsVm("image/dmargs", { 'dom': self.vm.getDomid(), 'read': True } )
         self.vm.storeVm(("rtc/timeoffset", rtc_timeoffset))
+        self.vm.permissionsVm("rtc/timeoffset", { 'dom': self.vm.getDomid(), 'read': True } )
 
         self.apic = int(vmConfig['platform'].get('apic', 0))
         self.acpi = int(vmConfig['platform'].get('acpi', 0))

diff --git a/tools/python/xen/xend/xenstore/xsutil.py b/tools/python/xen/xend/xenstore/xsutil.py
index 7ef00c22264ddb57fa5aa53ff45796be5f8dd333..b1bf69daf506717e2e571a963cbb8d0ad42148f2 100644 (file)
--- a/tools/python/xen/xend/xenstore/xsutil.py
+++ b/tools/python/xen/xend/xenstore/xsutil.py
@@ -22,6 +22,9 @@ def xshandle():
 def IntroduceDomain(domid, page, port):
     return xshandle().introduce_domain(domid, page, port)
 
+def SetTarget(domid, target):
+    return xshandle().set_target(domid, target)
+
 def GetDomainPath(domid):
     return xshandle().get_domain_path(domid)
 

diff --git a/tools/xenstore/xenstored_core.c b/tools/xenstore/xenstored_core.c
index acf6dd3918f256c68be62edf5c63a1de914b9059..7f20e30ca0d72e81cdd0bf0a656e0a4ca87fc2e3 100644 (file)
--- a/tools/xenstore/xenstored_core.c
+++ b/tools/xenstore/xenstored_core.c
@@ -119,6 +119,7 @@ static char *sockmsg_string(enum xsd_sockmsg_type type)
        case XS_ERROR: return "ERROR";
        case XS_IS_DOMAIN_INTRODUCED: return "XS_IS_DOMAIN_INTRODUCED";
        case XS_RESUME: return "RESUME";
+       case XS_SET_TARGET: return "SET_TARGET";
        default:
                return "**UNKNOWN**";
        }
@@ -283,6 +284,8 @@ static int destroy_conn(void *_conn)
                                break;
                close(conn->fd);
        }
+        if (conn->target)
+                talloc_unlink(conn, conn->target);
        list_del(&conn->list);
        trace_destroy(conn, "connection");
        return 0;
@@ -472,11 +475,13 @@ static enum xs_perm_type perm_for_conn(struct connection *conn,
                mask &= ~XS_PERM_WRITE;
 
        /* Owners and tools get it all... */
-       if (!conn->id || perms[0].id == conn->id)
+       if (!conn->id || perms[0].id == conn->id
+                || (conn->target && perms[0].id == conn->target->id))
                return (XS_PERM_READ|XS_PERM_WRITE|XS_PERM_OWNER) & mask;
 
        for (i = 1; i < num; i++)
-               if (perms[i].id == conn->id)
+               if (perms[i].id == conn->id
+                        || (conn->target && perms[i].id == conn->target->id))
                        return perms[i].perms & mask;
 
        return perms[0].perms & mask;
@@ -1245,6 +1250,10 @@ static void process_message(struct connection *conn, struct buffered_data *in)
                do_resume(conn, onearg(in));
                break;
 
+       case XS_SET_TARGET:
+               do_set_target(conn, in);
+               break;
+
        default:
                eprintf("Client unknown operation %i", in->hdr.msg.type);
                send_error(conn, ENOSYS);

diff --git a/tools/xenstore/xenstored_core.h b/tools/xenstore/xenstored_core.h
index d46d77f026b2353b1e03d87623ae37891114c8ff..975a97226f3541b8b00e7e14f206a21cad48801f 100644 (file)
--- a/tools/xenstore/xenstored_core.h
+++ b/tools/xenstore/xenstored_core.h
@@ -84,6 +84,9 @@ struct connection
        /* The domain I'm associated with, if any. */
        struct domain *domain;
 
+        /* The target of the domain I'm associated with. */
+        struct connection *target;
+
        /* My watches. */
        struct list_head watches;
 

diff --git a/tools/xenstore/xenstored_domain.c b/tools/xenstore/xenstored_domain.c
index ed422a52aa0db6a68c3e5f0309109b937df12330..2cc9881eb45477b5c207036b7b06af40b77f3453 100644 (file)
--- a/tools/xenstore/xenstored_domain.c
+++ b/tools/xenstore/xenstored_domain.c
@@ -381,6 +381,51 @@ void do_introduce(struct connection *conn, struct buffered_data *in)
        send_ack(conn, XS_INTRODUCE);
 }
 
+void do_set_target(struct connection *conn, struct buffered_data *in)
+{
+       char *vec[2];
+       unsigned int domid, tdomid;
+        struct domain *domain, *tdomain;
+       if (get_strings(in, vec, ARRAY_SIZE(vec)) < ARRAY_SIZE(vec)) {
+               send_error(conn, EINVAL);
+               return;
+       }
+
+       if (conn->id != 0 || !conn->can_write) {
+               send_error(conn, EACCES);
+               return;
+       }
+
+       domid = atoi(vec[0]);
+       tdomid = atoi(vec[1]);
+
+        domain = find_domain_by_domid(domid);
+       if (!domain) {
+               send_error(conn, ENOENT);
+               return;
+       }
+        if (!domain->conn) {
+               send_error(conn, EINVAL);
+               return;
+       }
+
+        tdomain = find_domain_by_domid(tdomid);
+       if (!tdomain) {
+               send_error(conn, ENOENT);
+               return;
+       }
+
+        if (!tdomain->conn) {
+               send_error(conn, EINVAL);
+               return;
+       }
+
+        talloc_reference(domain->conn, tdomain->conn);
+        domain->conn->target = tdomain->conn;
+
+       send_ack(conn, XS_SET_TARGET);
+}
+
 /* domid */
 void do_release(struct connection *conn, const char *domid_str)
 {

diff --git a/tools/xenstore/xenstored_domain.h b/tools/xenstore/xenstored_domain.h
index 69fdb77c1a9e9625e84c42c5487724632f86bdd4..f42a9f50adad9d03f5d5d38a74c40a1429ff2edf 100644 (file)
--- a/tools/xenstore/xenstored_domain.h
+++ b/tools/xenstore/xenstored_domain.h
@@ -34,6 +34,9 @@ void do_release(struct connection *conn, const char *domid_str);
 /* domid */
 void do_resume(struct connection *conn, const char *domid_str);
 
+/* domid, target */
+void do_set_target(struct connection *conn, struct buffered_data *in);
+
 /* domid */
 void do_get_domain_path(struct connection *conn, const char *domid_str);
 

diff --git a/tools/xenstore/xs.c b/tools/xenstore/xs.c
index a8152577980867fe692d58fcb229ca862460d2b5..dbbf8ef3947dfb0a683087e7da9e1d986a0fb35a 100644 (file)
--- a/tools/xenstore/xs.c
+++ b/tools/xenstore/xs.c
@@ -708,6 +708,25 @@ bool xs_introduce_domain(struct xs_handle *h,
                                ARRAY_SIZE(iov), NULL));
 }
 
+bool xs_set_target(struct xs_handle *h,
+                        unsigned int domid, unsigned int target)
+{
+       char domid_str[MAX_STRLEN(domid)];
+       char target_str[MAX_STRLEN(target)];
+       struct iovec iov[2];
+
+       snprintf(domid_str, sizeof(domid_str), "%u", domid);
+       snprintf(target_str, sizeof(target_str), "%u", target);
+
+       iov[0].iov_base = domid_str;
+       iov[0].iov_len = strlen(domid_str) + 1;
+       iov[1].iov_base = target_str;
+       iov[1].iov_len = strlen(target_str) + 1;
+
+       return xs_bool(xs_talkv(h, XBT_NULL, XS_SET_TARGET, iov,
+                               ARRAY_SIZE(iov), NULL));
+}
+
 static void * single_with_domid(struct xs_handle *h,
                                enum xsd_sockmsg_type type,
                                unsigned int domid)

diff --git a/tools/xenstore/xs.h b/tools/xenstore/xs.h
index c855614675e9df818e83e552d9ea3bf3d133a380..dd8cbf8c956f7de957507c8d9b74f3027be5a83b 100644 (file)
--- a/tools/xenstore/xs.h
+++ b/tools/xenstore/xs.h
@@ -132,6 +132,15 @@ bool xs_introduce_domain(struct xs_handle *h,
                         unsigned int domid,
                         unsigned long mfn,
                          unsigned int eventchn); 
+
+/* Set the target of a domain
+ * This tells the store daemon that a domain is targetting another one, so
+ * it should let it tinker with it.
+ */
+bool xs_set_target(struct xs_handle *h,
+                  unsigned int domid,
+                  unsigned int target);
+
 /* Resume a domain.
  * Clear the shutdown flag for this domain in the store.
  */

diff --git a/xen/include/public/io/xs_wire.h b/xen/include/public/io/xs_wire.h
index 3994b11fdfd75f179dcb0cf894c240d26d0e4ea5..103909351613f3aaac9097d63814048ac5e2f53d 100644 (file)
--- a/xen/include/public/io/xs_wire.h
+++ b/xen/include/public/io/xs_wire.h
@@ -46,7 +46,8 @@ enum xsd_sockmsg_type
     XS_WATCH_EVENT,
     XS_ERROR,
     XS_IS_DOMAIN_INTRODUCED,
-    XS_RESUME
+    XS_RESUME,
+    XS_SET_TARGET
 };
 
 #define XS_WRITE_NONE "NONE"